.TH std::filesystem::file_size 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::filesystem::file_size \- std::filesystem::file_size

.SH Synopsis
   Defined in header <filesystem>
   std::uintmax_t file_size( const std::filesystem::path& p ); \fB(1)\fP \fI(since C++17)\fP
   std::uintmax_t file_size( const std::filesystem::path& p,   \fB(2)\fP \fI(since C++17)\fP
                             std::error_code& ec ) noexcept;

   If p does not exist, reports an error.

   For a regular file p, returns the size determined as if by reading the st_size
   member of the structure obtained by POSIX stat (symlinks are followed).

   The result of attempting to determine the size of a directory (as well as any other
   file that is not a regular file or a symlink) is implementation-defined.

   The non-throwing overload returns static_cast<std::uintmax_t>(-1) on errors.

.SH Parameters

   p  - path to examine
   ec - out-parameter for error reporting in the non-throwing overload

.SH Return value

   The size of the file, in bytes.

.SH Exceptions

   Any overload not marked noexcept may throw std::bad_alloc if memory allocation
   fails.

   1) Throws std::filesystem::filesystem_error on underlying OS API errors, constructed
   with p as the first path argument and the OS error code as the error code argument.
   2) Sets a std::error_code& parameter to the OS API error code if an OS API call
   fails, and executes ec.clear() if no errors occur.

.SH Example


// Run this code

 #include <cmath>
 #include <filesystem>
 #include <fstream>
 #include <iostream>
 namespace fs = std::filesystem;

 struct HumanReadable
 {
     std::uintmax_t size{};

 private:
     friend std::ostream& operator<<(std::ostream& os, HumanReadable hr)
     {
         int o{};
         double mantissa = hr.size;
         for (; mantissa >= 1024.; mantissa /= 1024., ++o);
         os << std::ceil(mantissa * 10.) / 10. << "BKMGTPE"[o];
         return o ? os << "B (" << hr.size << ')' : os;
     }
 };

 int main(int, char const* argv[])
 {
     fs::path example = "example.bin";
     fs::path p = fs::current_path() / example;
     std::ofstream(p).put('a'); // create file of size 1
     std::cout << example << " size = " << fs::file_size(p) << '\\n';
     fs::remove(p);

     p = argv[0];
     std::cout << p << " size = " << HumanReadable{fs::file_size(p)} << '\\n';

     try
     {
         std::cout << "Attempt to get size of a directory:\\n";
         [[maybe_unused]] auto x_x = fs::file_size("/dev");
     }
     catch (fs::filesystem_error& e)
     {
         std::cout << e.what() << '\\n';
     }

     for (std::error_code ec; fs::path bin : {"cat", "mouse"})
     {
         bin = "/bin"/bin;
         if (const std::uintmax_t size = fs::file_size(bin, ec); ec)
             std::cout << bin << " : " << ec.message() << '\\n';
         else
             std::cout << bin << " size = " << HumanReadable{size} << '\\n';
     }
 }

.SH Possible output:

 "example.bin" size = 1
 "./a.out" size = 22KB (22512)
 Attempt to get size of a directory:
 filesystem error: cannot get file size: Is a directory [/dev]
 "/bin/cat" size = 50.9KB (52080)
 "/bin/mouse" : No such file or directory

.SH See also

   resize_file changes the size of a regular file by truncation or zero-fill
   \fI(C++17)\fP     \fI(function)\fP
   space       determines available free space on the file system
   \fI(C++17)\fP     \fI(function)\fP
   file_size   returns the size of the file to which the directory entry refers
               \fI(public member function of std::filesystem::directory_entry)\fP
